﻿//* ==========================================================================
// Classe : Expressions 
// Fonctions : Classe de gestion des expressions régulières 
//
// License:  License LGPL 
// Version :  0.01 du 24/07/2009 
// Lien : http://outils.codeplex.com 
// Auteur(s) : JF. PACORY
// CopyLeft  :  CopyLeft (>) 2008-2009 GlopSoft <contact@glopsoft.com>
// Création : 07/24/2009 00:37:55
// Etat : en cours
// Controle du :
// Licence : 
// L'autorisation est accordée, à titre gratuit, à toute personne d'obtenir une copie 
// de ce logiciel et de ses fichiers de documentation, pour pouvoir utiliser 
//ce logiciel sans restriction, y compris, sans s'y limiter, les droits 
// d'utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, 
// de sous-licence, et / ou de vendre les copies du Logiciel, et d'autoriser les 
// personnes auxquelles le logiciel est livré de le faire, sous réserve des 
// conditions suivantes:
// 
// Les avis de droit d'auteur et la présente autorisation doivent être inclus dans 
// toutes les copies ou parties substantielles du Logiciel.
// 
// LE LOGICIEL EST FOURNI "TEL QUEL", SANS GARANTIE DE QUELQUE NATURE QUE CE SOIT, 
// EXPLICITE OU  IMPLICITE, Y COMPRIS, MAIS SANS Y LIMITER LES GARANTIES DE QUALITE 
// MARCHANDE, D'ADEQUATION A UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN 
// AUCUN CAS LES AUTEURS OU LES TITULAIRES DE DROITS D'AUTEUR POURRONT ETRE TENUE 
// RESPONSABLES DE TOUT DOMMAGE,  RÉCLAMATION OU AUTRE  RESPONSABILITE, DANS LE 
// CADRE D'UNE ACTION DE CONTRAT, UN DELIT OU AUTRE, DÉCOULANT DE, OU EN RELATION 
// AVEC LE LOGICIEL OU DE SON UTILISATION OU AUTRES EN RELATION AVEC LE LOGICIEL.
// Licence LGPL : http://commonlibrarynet.codeplex.com/license 
//*---------------------------------------------------------------------------
//
//* ==========================================================================
#region Références

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Globalization;
using System.Diagnostics;
using System.Text.RegularExpressions;

#endregion

namespace Outils.ExpressionsRegulieres
{
    /// <summary>
    ///	 Classe de gestion des expressions régulières 
    ///	</summary>	
    public static  class Expressions
    {
        #region Initialisation, finalisation

        #region Constructeurs

        
        #endregion

        #endregion

        #region Attributs, Propriétés et Constantes


        #endregion

        #region Attributs


        #endregion

        #region Propriétés


        #endregion

        #region Constantes


        #endregion

        #region Chargement


        #endregion

        #region Méthodes privées


        #endregion

        #region Méthodes publiques

        /// <summary>
        /// Vérifie si une expression est correcte
        /// </summary>
        /// <param name="sChaine">chaine à vérifier</param>
        /// <param name="sExpressionReguliere"></param>
        /// <returns>vrai si chaine est correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static  bool EstExpressionCorrecte ( string sChaine, string sExpressionReguliere )
        {
            try
            {
                //
                // SI chaine non nulle ou vide, tester l'expression, SINON retourner faux
                return string.IsNullOrEmpty(sChaine)? false : new Regex( sExpressionReguliere ).IsMatch( sChaine );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }


        /// <summary>
        /// Contrôle d'une adresse électronique
        /// </summary>
        /// <param name="sChaine">adresse électronique à contrôler</param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstAdresseElectronique ( string sChaine )
        {
            try
            {
                string sExpressionReguliere = @"\b[A-Z0-9._%-]++@[A-Z0-9._%-]+\.[A-Z]{2,4}\b";
                return EstExpressionCorrecte( sChaine, sExpressionReguliere );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }
         
        /// <summary>
        /// Fonction de test des entiers positifs strictement
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstNombreEntierNaturel ( string sValeurNumerique )
        {
            try
            {
                Regex objNotNaturalExpression = new Regex( "[^0-9]" );
                Regex objNaturalExpression = new Regex( "0*[1-9][0-9]*" );
                return !objNotNaturalExpression.IsMatch( sValeurNumerique ) &&
                objNaturalExpression.IsMatch( sValeurNumerique );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }

        /// <summary>
        /// Fonction de test des entiers positifs 
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstNombreEntier ( string sValeurNumerique )
        {
            try
            {
            Regex objNotWholeExpression = new Regex( "[^0-9]" );
            return !objNotWholeExpression.IsMatch( sValeurNumerique );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }

        /// <summary>
        /// Fonction de test des entiers positifs et négatifs
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstEntier( string sValeurNumerique )
        {
            try
            {
            Regex objNotIntExpression = new Regex( "[^0-9-]" );
            Regex objIntExpression = new Regex( "^-[0-9]+$|^[0-9]+$" );
            return !objNotIntExpression.IsMatch( sValeurNumerique ) && objIntExpression.IsMatch( sValeurNumerique );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }
        
        /// <summary>
        /// Fonction de test des nombres positifs réels 
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstNombrePositif ( string sValeurNumerique )
        {
            try
            {
                Regex objNotPositiveExpression = new Regex( "[^0-9.]" );
                Regex objPositiveExpression = new Regex( "^[.][0-9]+$|[0-9]*[.]*[0-9]+$" );
                Regex objTwoDotExpression = new Regex( "[0-9]*[.][0-9]*[.][0-9]*" );
                return !objNotPositiveExpression.IsMatch( sValeurNumerique ) &&
                objPositiveExpression.IsMatch( sValeurNumerique ) &&
                !objTwoDotExpression.IsMatch( sValeurNumerique );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }    

        /// <summary>
        /// Fonction de test des nombres positifs réels 
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstNombreReel ( string sValeurNumerique )
        {
            try
            {
                Regex objNotNumberExpression = new Regex( "[^0-9.-]" );
                Regex objTwoDotExpression = new Regex( "[0-9]*[.][0-9]*[.][0-9]*" );
                Regex objTwoMinusExpression = new Regex( "[0-9]*[-][0-9]*[-][0-9]*" );
                string strValidRealExpression = "^([-]|[.]|[-.]|[0-9])[0-9]*[.]*[0-9]+$";
                string strValidIntegerExpression = "^([-]|[0-9])[0-9]*$";
                Regex objNumberExpression = new Regex( "(" + strValidRealExpression + ")|(" + strValidIntegerExpression + ")" );
                return !objNotNumberExpression.IsMatch( sValeurNumerique ) &&
                !objTwoDotExpression.IsMatch( sValeurNumerique ) &&
                !objTwoMinusExpression.IsMatch( sValeurNumerique ) &&
                objNumberExpression.IsMatch( sValeurNumerique );
            }
            
            catch ( ArgumentException )
            {
                throw;
            }
        }
       
        /// <summary>
        /// Fonction de test des chaines alpha
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstAlpha ( string sChaine )
        {
            try
            {
                string sExpressionReguliere = @"[^a-zA-Z]";
                return EstExpressionCorrecte( sChaine, sExpressionReguliere );
            }
       
            catch ( ArgumentException )
            {
                throw;
            }
        }

        /// <summary>
        /// Fonction de test des chaines alphanumériques
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstAlphaNumerique ( string sChaine )
        {
            try
            {
                string sExpressionReguliere = @"[^a-zA-Z0-9]";
                return !EstExpressionCorrecte( sChaine, sExpressionReguliere );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }

        /// <summary>
        /// Fonction de test des chaines alphanumériques avec accents
        /// </summary>
        /// <param name="sValeurNumerique"></param>
        /// <returns>vrai pour une valeur correcte, sinon faux</returns>
        /// <exception cref="ArgumentException">erreur de paramètre</exception>
        public static bool EstAlphaNumeriqueAccentuee ( string sChaine )
        {
            try
            {
                string sExpressionReguliere = @"[^a-zA-Z0-9]";
                return !EstExpressionCorrecte( sChaine, sExpressionReguliere );
            }

            catch ( ArgumentException )
            {
                throw;
            }
        }

        #endregion

        #region Méthodes protégées


        #endregion

    }
}